package bszt.jd;

import java.util.Scanner;

public class Code06 {

    /**
     * 问题描述
     * 在一片神秘的魔法森林中，有一条由2行N列的魔法石阵组成的道路。每块魔法石上都刻有一个数字，代表其蕴含的魔力值。森林守护者K小姐和森林探险家A先生正在进行一场特殊的冒险游戏
     * 游戏规则如下：
     * 从起点(1,1)出发，通过向上、向下或向右移动，最终到达终点(2,N)
     * 每块魔法石只能踩踏一次
     * K小姐和A先生轮流选择下一块要踩踏的魔法石，K小姐先手
     * 当有人到达终点(2,N)时，游戏结束
     * 路径的魔力值定义为路径上所有魔法石数字的总和。K小姐希望最大化路径的魔力值，而A先生则希望最小化路径的魔力值
     * 假设两人都采取最优策略，请计算最终路径的魔力值。
     * <p></p>
     * 输入格式
     * 第一行包含一个整数N，表示魔法石阵的列数
     * 接下来两行，每行包含N个整数，表示魔法石阵中每块石头的魔力值
     * <p></p>
     * 输出格式
     * 输出一个整数，表示在双方都采取最优策略的情况下，最终路径的魔力值
     */

    static final long INF = (long) 1e18;
    static int[][] magicStones = new int[2][200005];
    // dp[p][i][j][k]  p：当前玩家 i：当前行 k：当前列 j：已经走过的路径状态（0：未走过，1：已走过）
    static long[][][][] dp1 = new long[2][2][4][200005];
    static long[][][][] dp2 = new long[2][2][4][200005];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        solveGame(sc);
    }

    static void solveGame(Scanner sc) {
        int columns = sc.nextInt();

        // 读取魔法石阵的魔力值
        for (int row = 0; row < 2; row++) {
            for (int col = 1; col <= columns; col++) {
                magicStones[row][col] = sc.nextInt();
                if (col == columns) {
                    // 初始化终点状态
                    for (int state = 0; state < 4; state++) {
                        dp1[0][row][state][col] = INF;
                        dp2[1][row][state][col] = -INF;
                    }
                } else {
                    // 初始化非终点状态
                    for (int state = 0; state < 4; state++) {
                        dp1[0][row][state][col] = -INF;
                        dp2[1][row][state][col] = INF;
                    }
                }
            }
        }

        // 动态规划过程
        for (int col = columns; col >= 1; col--) {
            if (col == columns) {
                // 处理终点情况
                dp1[0][1][2][col] = dp2[1][1][2][col] = magicStones[1][col];
                dp1[0][0][3][col] = dp2[1][0][3][col] = magicStones[1][col] + magicStones[0][col];
            } else {
                for (int state = 0; state <= 3; state++) {
                    for (int row = 0; row < 2; row++) {
                        if ((state & (1 << row)) != 0) {
                            if (state != 3) {
                                // 向右移动的情况
                                dp1[0][row][state][col] = Math.max(dp1[0][row][state][col],
                                        Math.max(dp2[1][row][state][col + 1] + magicStones[row][col],
                                                dp2[1][row][3][col + 1] + magicStones[row][col]));
                                dp2[1][row][state][col] = Math.min(dp2[1][row][state][col],
                                        Math.min(dp1[0][row][state][col + 1] + magicStones[row][col],
                                                dp1[0][row][3][col + 1] + magicStones[row][col]));
                            } else {
                                // 向上/下移动的情况
                                dp1[0][row][state][col] = Math.max(dp1[0][row][state][col],
                                        dp2[1][row ^ 1][state ^ (1 << row)][col] + magicStones[row][col]);
                                dp2[1][row][state][col] = Math.min(dp2[1][row][state][col],
                                        dp1[0][row ^ 1][state ^ (1 << row)][col] + magicStones[row][col]);
                            }
                        }
                    }
                }
            }
        }

        // 输出结果：起点的最优值
        System.out.println(Math.min(dp1[0][0][3][1], dp1[0][0][1][1]));
    }
}
